package com.yyy.tcc.service.compensation;

/**
 * 演示volatile关键字的特性
 */
public class VolatileDemo {
    // volatile只能保证可见性，不能保证原子性
    private volatile int count = 0;

    // AtomicInteger底层结构示意
    private static class AtomicIntegerSimulation {
        // 使用volatile保证value的可见性
        private volatile int value;

        // 底层通过native方法实现CAS
        public final boolean compareAndSet(int expect, int update) {
            // 实际上是调用Unsafe的native方法
            // return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
            return false; // 这里只是演示
        }

        public final int incrementAndGet() {
            for (;;) {
                int current = value;    // 获取当前值
                int next = current + 1; // 计算新值
                if (compareAndSet(current, next)) // CAS尝试更新
                    return next;
            }
        }
    }

    /**
     * 演示volatile不能保证原子性
     */
    public void demonstrateNonAtomic() throws InterruptedException {
        Thread[] threads = new Thread[10];

        // 创建10个线程，每个线程对count进行1000次自增
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    count++; // 非原子操作
                }
            });
            threads[i].start();
        }

        // 等待所有线程完成
        for (Thread thread : threads) {
            thread.join();
        }

        // 预期结果应该是10000，但实际会小于这个值
        System.out.println("Expected: 10000, Actual: " + count);
    }

    /**
     * volatile的三个特性演示
     */
    public static void volatileFeatures() {
        // 1. 可见性：一个线程修改了volatile变量，其他线程立即可见
        class VisibilityDemo {
            private volatile boolean flag = false;

            public void write() {
                flag = true; // 修改立即对其他线程可见
            }

            public void read() {
                while (!flag) {
                    // 可以立即看到其他线程对flag的修改
                }
            }
        }

        // 2. 禁止指令重排序
        class ReorderingDemo {
            private volatile int value = 0;
            private int status = 0;

            public void write() {
                status = 1;    // 1
                value = 42;    // 2: volatile写
                // volatile保证1一定在2之前执行
            }

            public void read() {
                int v = value; // 1: volatile读
                int s = status;// 2
                // volatile保证2一定在1之后执行
            }
        }
    }

    /**
     * AtomicInteger如何实现原子性
     */
    public static void atomicImplementation() {
        // AtomicInteger的底层实现依赖于:
        // 1. volatile变量保证可见性
        // 2. CAS操作保证原子性
        class AtomicIntegerStructure {
            private volatile int value; // 保证可见性

            public final int incrementAndGet() {
                for (;;) {
                    int current = value;
                    int next = current + 1;
                    // CAS操作，保证原子性
                    if (compareAndSet(current, next))
                        return next;
                }
            }

            private boolean compareAndSet(int expect, int update) {
                // 底层调用native方法
                // return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
                return false;
            }
        }
    }
}
